import { BG_URL, KEY } from './config'

// 时间格式处理
export const formatDate = (date, format) => {
  if (/(y+)/.test(format)) {
    format = format.replace(RegExp.$1, (date.getFullYear() + '').substring(4 - RegExp.$1.length))
  }
  let o = {
    'M+': date.getMonth() + 1,
    'd+': date.getDate(),
    'h+': date.getHours(),
    'm+': date.getMinutes(),
    's+': date.getSeconds()
  }
  for (let k in o) {
    let reg = new RegExp(`(${k})`)
    if (reg.test(format)) {
      let str = o[k] + ''
      format = format.replace(RegExp.$1, (RegExp.$1.length === 1) ? str : tool.addZero(str))
    }
  }
  return format
}

// 滚动监听
export const wScroll = (callback) => {
  let timer
  function fnScroll() {
    if (timer) {
      clearTimeout(timer)
    }
    timer = setTimeout(() => {
      callback && callback(document.body.scrollTop || document.documentElement.scrollTop)
    }, 10)
  }
  return {
    mount() {
      window.addEventListener('scroll', fnScroll, false)
    },
    unmount() {
      window.removeEventListener('scroll', fnScroll, false)
    }
  }
}

// localStorage
export const storage = {
  get(key) {
    return JSON.parse(localStorage.getItem(key))
  },
  set(key, value) {
    localStorage.setItem(key, JSON.stringify(value))
  },
  remove(key) {
    localStorage.removeItem(key)
  },
  clear() {
    localStorage.clear()
  }
}

// sessionStorage
export const session = {
  get(key) {
    return JSON.parse(sessionStorage.getItem(key))
  },
  set(key, value) {
    sessionStorage.setItem(key, JSON.stringify(value))
  },
  remove(key) {
    sessionStorage.removeItem(key)
  },
  clear() {
    sessionStorage.clear()
  }
}

// cookie操作
export const cookie = {
  get(key) {
    let arr = []
    let reg = new RegExp('(^| )' + key + '=([^;]*)(;|$)')

    // 如果获取到cookie，则直接返回数据
    if (arr=document.cookie.match(reg)) {
      return unescape(arr[2])
    }
    return null;
  },
  set(key, value, time) {
    let Days = 30
    let exp = new Date()
    exp.setTime(exp.getTime() + Days * 24 * 60 * 60 * 1000)
    document.cookie = key + "="+ escape (value) + ";expires=" + exp.toGMTString();
  },
  remove(key) {
    let exp = new Date()
    exp.setTime(exp.getTime() - 1)
    let cval = cookie.get(key)
    if(cval) {
      document.cookie= name + "="+cval+";expires="+exp.toGMTString()
    }
  }
}

// 方法
export const tool = {
  addZero(str) {
    str = str.toString()
    return ('00' + str).substring(str.length)
  }
}

// 字符串验证
export const verify = {
  isPhone(value) {
    return /(^1[0-9]{10}$)/.test(value)
  },
  isPassword(value) {
    return /^\w{6,16}$/.test(value)
  },
  isNull(value) {
    return value.length
  }
}

// 页面滚动方法
export const windowScroll = {
  callback: [],
  // 初始化页面滚动事件
  init() {
    // 如果设置了滚动事件，则不操作
    if (window.onscroll) {
      return
    }

    // 设置滚动事件
    window.onscroll = () => {
      return this.callback.forEach((fn) => { fn() })
    }
  },
  // 销毁滚动事件
  destroy() {
    window.onscroll = ''
  },
  // 设置回调方法
  setCallBack(fn) {
    // 如果是方法，则放到回调函数中
    if (typeof fn == 'function') {
      this.callback.push(fn)
    }
  }
}

// 将参数转换成对象
export const parseQueryString = (url) => {
  // 将url转义
  url = decodeURIComponent(url)
  // 匹配的正则
  let reg_url = /^[^\?]+\?([\w\W]+)$/
  let reg_para = /([^&=]+)=([\w\W]*?)(&|$)/g
  let arr_url = reg_url.exec(url)
  let ret = {}
  if (arr_url && arr_url[1]) {
      var str_para = arr_url[1], result;
      while ((result = reg_para.exec(str_para)) != null) {
          ret[result[1]] = result[2];
      }
  }
  return ret;
}

/**
 * 将参数追加到url上去
 *
 * @param { String } url    需要追加的url链接
 * @param { Object } params 需要追加的参数
 */
export const joinQueryParamsToUrl = (url = '', params) => {
  // 将之前的参数截取（不要了）
  let urlPrefix = `${url.split('?')[0]}?`
  // 将参数全部获取
  for(let p in params) {
    // 如果参数中有值，则直接追加上url中
    if (params[p]) {
      urlPrefix += `${p}=${params[p]}&`
    }
  }
  return urlPrefix.substr(0, urlPrefix.length - 1)
}

/**
 * 打开新窗口
 *
 * @param { String } url 链接
 */
export const openWindow = (url) => {
  var a = document.createElement("a"); //创建a对象
  a.setAttribute("href", url);
  a.setAttribute("target", "_blank");
  a.setAttribute("id", "camnpr");
  document.body.appendChild(a);
  a.click(); //执行当前对象
}

/**
 * 跳转到商家后台的页面（免登陆）
 *
 * @param { String } url    后台需要跳转的链接
 * @param { String } target 打开方式
 */
export const toShopUrl = (url = '/login', target = '_blank') => {
  // 获取用户登录信息
  let userInfo = session.get('userInfo') || {}

  // 如果当前不是供应商
  if (userInfo.userRole != 'SELLER') {
    url = '/login'
  }

  // 如果url第一个字符不是 / ,则追加上
  if (url.indexOf('/') != 0) {
    url = `\\${url}`
  }

  // 如果登录了，则带上此参数
  let key = ''

  // 如果用户已经登录，则将用户信息加密
  if (userInfo.accessToken) {
    key = encrypt([userInfo.accessToken, userInfo.userName, userInfo.storeId].join(','))
  }

  // 如果是新打开页面
  if (target == '_blank') {
    // 如果用户没有登录
    if (!key) {
      window.open(`${BG_URL}${url}`)
      return
    }
    // 从登陆信息中判断是否是供应商
    window.open(`${BG_URL}${url}?key=${key}`)
  }

  // 如果是当前页打开
  if (target == '_self') {
    // 如果用户没有登录
    if (!key) {
      window.location.href = `${BG_URL}${url}`
      return
    }
    // 从登陆信息中判断是否是供应商
    window.location.href = `${BG_URL}${url}?key=${key}`
  }
}

/**
 * 加密
 * @param { String/Object } str 待加密的文字或对象 
 */
export const encrypt = (str) => {
  let prand = ''; 
	for(let i = 0; i < KEY.length; i ++) { 
		prand += KEY.charCodeAt(i).toString(); 
	} 
	let sPos = Math.floor(prand.length / 5); 
	let mult = parseInt(prand.charAt(sPos) + prand.charAt(sPos * 2) + prand.charAt(sPos * 3) + prand.charAt(sPos * 4) + prand.charAt(sPos * 5)); 
	let incr = Math.ceil(KEY.length / 2); 
	let modu = Math.pow(2, 31) - 1; 
	let salt = Math.round(Math.random() * 1000000000) % 100000000; 
	prand += salt; 
	while(prand.length > 10) { 
		prand = (parseInt(prand.substring(0, 10)) + parseInt(prand.substring(10, prand.length))).toString(); 
	} 
	prand = (mult * prand + incr) % modu; 
	let enc_chr = ""; 
	let enc_str = ""; 
	for(let i=0; i<str.length; i++) { 
		enc_chr = parseInt(str.charCodeAt(i) ^ Math.floor((prand / modu) * 255)); 
		if(enc_chr < 16) { 
			enc_str += "0" + enc_chr.toString(16); 
		} else enc_str += enc_chr.toString(16); 
		prand = (mult * prand + incr) % modu; 
	} 
	salt = salt.toString(16); 
	while(salt.length < 8) salt = "0" + salt; 
	enc_str += salt; 
	return enc_str; 
}

/**
 * 解密
 * @param { String/Object } str 待解密的内容
 */
export const decrypt = (str) => {
  let prand = ""; 
	for(let i = 0; i < KEY.length; i++) { 
		prand += KEY.charCodeAt(i).toString(); 
	} 
	let sPos = Math.floor(prand.length / 5); 
	let mult = parseInt(prand.charAt(sPos) + prand.charAt(sPos * 2) + prand.charAt(sPos * 3) + prand.charAt(sPos * 4) + prand.charAt(sPos * 5)); 
	let incr = Math.round(KEY.length / 2); 
	let modu = Math.pow(2, 31) - 1; 
	let salt = parseInt(str.substring(str.length - 8, str.length), 16);
	str = str.substring(0, str.length - 8); 
	prand += salt; 
	while(prand.length > 10) { 
		prand = (parseInt(prand.substring(0, 10)) + parseInt(prand.substring(10, prand.length))).toString(); 
	} 
	prand = (mult * prand + incr) % modu; 
	let enc_chr = ""; 
	let enc_str = ""; 
	for(let i = 0; i < str.length; i += 2) { 
		enc_chr = parseInt(parseInt(str.substring(i, i+2), 16) ^ Math.floor((prand / modu) * 255)); 
		enc_str += String.fromCharCode(enc_chr); 
		prand = (mult * prand + incr) % modu; 
	} 
	return enc_str;
}